import axios from 'axios'
import storage from '@/core/storage'
import Global from '@/config/global'
import { Message, Notification, MessageBox } from 'element-ui'

var isRelogin = true
const request = axios.create({
  baseURL: '/api', // 因为我本地做了反向代理
  timeout: 60000,
  responseType: 'json',
  withCredentials: true, // 是否允许带cookie这些
  headers: {
    'Content-Type': 'multipart/form-data;charset=utf-8'
  }
})

var call = {}

// POST传参序列化(添加请求拦截器)
request.interceptors.request.use(
  config => {
    // 若是有做鉴权token , 就给头部带上token
    // 若是需要跨站点,存放到 cookie 会好一点,限制也没那么多,有些浏览环境限制了 localstorage 的使用
    // 这里localStorage一般是请求成功后我们自行写入到本地的,  因为你放在vuex刷新就没了
    // 一些必要的数据写入本地,优先从本地读取
    config.onUploadProgress = (progressEvent) => {
      if (progressEvent.lengthComputable) {
        // 属性lengthComputable主要表明总共需要完成的工作量和已经完成的工作是否可以被测量
        // 如果lengthComputable为false，就获取不到progressEvent.total和progressEvent.loaded
        call.progressEvent(progressEvent)
      }
    }
    if (storage.getSession()) {
      config.headers.Authorization = storage.getSession()
    }
    return config
  },
  error => {
    return Promise.reject(error.data.error.message)
  }
)

// 返回状态判断(添加响应拦截器) 这里与 post.js 中的文件方法一致
request.interceptors.response.use(
  response => {
    // 对响应数据做些事
    if (!response.data) {
      return null
    }
    const data = response.data

    if (!data) {
      return null
    }

    // 错误状态码不等于200的操作
    if (data.code && parseInt(data.code) !== 200) {
      // 请求出现错误
      console.warn(data)
      // 如果大于等于 600 则清除 session 然后返回至登录页面
      if (parseInt(data.code) >= 600 && isRelogin) {
        isRelogin = false
        let message = ''
        if (typeof data.message === 'string') {
          message = data.message
        } else {
          message = '登录超时！'
        }
        storage.clsSession()
        MessageBox({
          title: '提示',
          message: message,
          confirmButtonText: '关闭',
          type: 'warning'
        })
          .then(() => {
            window.location.href = Global.loginUrl
          })
          .catch(() => {
            window.location.href = Global.loginUrl
          })
        return
      }
    }

    /**
     * 接收的内容对应的提示消息
     */
    // 消息提示
    if (data.console) {
      for (let key in data.console) {
        switch (key) {
          case 'error':
            console.error(data.console[key])
            break
          case 'info':
            console.info(data.console[key])
            break
          case 'clear':
            console.clear(data.console[key])
            break
          case 'log':
            console.log(data.console[key])
            break
          case 'warn':
            console.warn(data.console[key])
            break
          default:
            console.log(data.console)
            break
        }
      }
    }
    // 消息提示
    if (data.message) {
      Message(data.message)
    }
    // 消息弹框
    if (data.messageBox) {
      MessageBox(data.messageBox).catch(() => {})
    }
    // 通知提示
    if (data.notification) {
      Notification(data.notification)
    }

    // 判断数据中是否存在 session，如果存在则将 session 保存至本地
    if (data.data && data.data.session) {
      const session = data.data.session
      storage.setSession(session)
      if (!storage.getSession()) {
        // 保存 session 失败
        Message({
          showClose: true,
          message: '请使用最新的Chrome浏览器或者360浏览器的极速模式！',
          type: 'error'
        })
      }
      delete data.data.session
    }

    return data.data ? data.data : null
  },
  error => {
    // 返回 response 里的错误信息
    console.error(error)
    Message.error('请求服务器失败！')
    return Promise.reject(error)
  }
)

function post (url, data = {}) {
  return new Promise((resolve, reject) => {
    request
      .post(url, data)
      .then(response => {
        resolve(response)
      })
      .catch(err => {
        reject(err)
      })
  })
}

export function upload (
  url,
  data = {},
  operation = {
    // 一开始的回调
    begin: () => {},
    // 成功的回调
    callback: () => {},
    // 失败的回调
    falisback: () => {},
    // 完成的回调
    complete: () => {},
    // 上传过程中的回调事件
    progressEvent: () => {}
  }
) {
  if (operation.progressEvent && typeof operation.progressEvent === 'function') {
    call.progressEvent = event => {
      operation.progressEvent(event)
    }
  }
  if (operation.begin && typeof operation.begin === 'function') {
    operation.begin()
  }
  return post(url, data).then(
    response => {
      if (operation.callback && typeof operation.callback === 'function') {
        operation.callback(response)
      }
      if (operation.complete && typeof operation.complete === 'function') {
        operation.complete(response)
      }
    },
    error => {
      if (operation.falisback && typeof operation.falisback === 'function') {
        operation.falisback(error)
      }
      if (operation.complete && typeof operation.complete === 'function') {
        operation.complete(error)
      }
      console.error(error)
    }
  )
}
